/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package projettni;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.text.DecimalFormat;
import java.util.HashMap;
import java.util.Map;

/**
 *
 * @author dverstraete
 */
public class ProjetTNITexte {

    /**
     * @param args
     */
    public static void main(String[] args) {


        char[] dico = creerDictionnaireTexte();
        Map<String, Float> probas = calculerProbasTexte(dico);
//        probas.put("a", 0.4F);
//        probas.put("b", 0.4F);
//        probas.put("c", 0.1F);
//        probas.put("d", 0.1F);
        Map<String, Float> probasCumulees = calculerProbasCumuleesTexte(dico, probas);
        char[] valeur = new char[]{'d', 'b','a','b','a', 'd','a','b','c','e','ù'};

        System.out.println(calculerTagTexte(valeur, probas, probasCumulees, dico));

        System.out.println("Proba " + probas.get("a"));
        System.out.println("Proba " + probas.get("b"));

    }

    /**
     * Retourne le tag de la série
     * @return
     */
    public static double calculerTagTexte(char[] tabCaracteres, Map<String, Float> proba,
            Map<String, Float> probasCumulees, char[] dictionnaire) {

        double fLn = 0F;
        double fUn = 1F;
        double fPcum = 0F;
        double fPelem = 0F;
        double fTag = 0F;

        //parcours du tableau de valeurs
        for (int i = 0; i < tabCaracteres.length; i++) {

            fPcum = probasCumulees.get(String.valueOf(tabCaracteres[i]));
            System.out.println("Pcum " + fPcum);
            fPelem = proba.get(String.valueOf(tabCaracteres[i]));
            System.out.println("Pelem " + fPelem);

            double tempfLn = Utilitaires.calc_ln(fLn, fUn, fPcum);
            double tempfUn = Utilitaires.calc_un(fLn, fUn, fPcum, fPelem);
            fLn = tempfLn;
            fUn = tempfUn;
            System.out.println("ITERATION " + i + " - Ln :" + fLn + " Un:" + fUn);
        }

        fTag = (fUn + fLn) / 2F;
        return fTag;
    }

    /**
     * Retourne le dictionnaire de caractères pour un texte
     * @return
     */
    public static char[] creerDictionnaireTexte() {
        return new char[]{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',
        'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
        '.', ',', '?', ';', ':', '!', '"', '\'',
        'é', 'è', 'à', 'ê', 'ç', 'ù'};
    }

    /**
     * Retourne les probabilités d'occurence de chaque caratère du dictionnaire passé en paramètre
     * dans le fichier exemple1.txt
     * @param dictionnaire
     * @return
     */
    public static Map<String, Float> calculerProbasTexte(char[] dictionnaire) {

        Map<String, Float> probabiliteDictionnaire = new HashMap<String, Float>();
        //variables
        String fichier = "exemple1.txt";
        String ligne;
        int nb_char = 0;

        //initialisation de la map de probas à 0
        for (char car : dictionnaire) {
            probabiliteDictionnaire.put(String.valueOf(car), 0F);
        }


        //parcours du fichier
        //comptage du nombre d'occurence de chaque lettre
        try {
            BufferedReader br = new BufferedReader(
                    new InputStreamReader(
                    new FileInputStream(fichier)));

            while ((ligne = br.readLine()) != null) {

                //passage de la ligne en minuscule
                ligne.toLowerCase();
                System.out.println(ligne);

                for (int i = 0; i < ligne.length(); i++) {

                    String caractere = String.valueOf(ligne.charAt(i));

                    //si le caractère existe
                    if (probabiliteDictionnaire.containsKey(caractere)) {
                        Float proba = probabiliteDictionnaire.get(caractere);
                        probabiliteDictionnaire.put(caractere, proba + 1F);
                        nb_char++;
                    }
                }
            }
        } catch (Exception e) {
            System.out.println(e.toString());
        }

        DecimalFormat df = new DecimalFormat();
        df.setMaximumFractionDigits(2);
        //calcul des probas
        for (String mapKey : probabiliteDictionnaire.keySet()) {
            Float proba = probabiliteDictionnaire.get(mapKey) / Float.valueOf(nb_char);
            probabiliteDictionnaire.put(mapKey, proba);
        }

        return probabiliteDictionnaire;
    }

    /**
     * Retourne les probabilités d'occurence cumulées de chaque caratère du dictionnaire passé en paramètre
     * dans le fichier exemple1.txt
     * @param dictionnaire
     * @return
     */
    public static Map<String, Float> calculerProbasCumuleesTexte(char[] dictionnaire, Map<String, Float> probas) {
        //variables
        Map<String, Float> probabiliteCumulees = new HashMap<String, Float>();
        Float sommeProbas = 0F;

        probabiliteCumulees.put(String.valueOf(dictionnaire[0]), 0F);
        
        for (int i = 1; i < dictionnaire.length; i++) {
            //probas de i-1
            sommeProbas += probas.get(String.valueOf(dictionnaire[i-1]));
            probabiliteCumulees.put(String.valueOf(dictionnaire[i]), sommeProbas);
        }

        return probabiliteCumulees;
    }
}
